interface NodeInfo {
    node: cc.Node;
    depth: number;
}

//xyFind(...args: Array<number | string>): cc.Node | null; 需要去声明文件中声明

/**如果传入两个参数一个字符串一个数字，则使用 DFS 算法，在节点树中查找深度为 depth 且名称为 name 的节点，并返回该节点。如果只传入一个字符串，则使用 BFS 算法，
 * 在节点树中查找第一个名称为 name 的节点，并返回该节点。
 * 如果传入一个数字参数，则返回该节点的第 position 个子节点。
 */
cc.Node.prototype.xyFind = function (...args: Array<number | string>): cc.Node | null {
    let depth: number | undefined;
    let name: string | undefined;
    let position: number | undefined;

    // 遍历参数，根据参数的类型和数量，来确定要使用哪种查找方式。
    if (args.length === 2) {
        for (let index = 0; index < args.length; index++) {
            const element = args[index];
            if (typeof element === 'string') {
                name = element
            } else {
                depth = element
            }
        }
    } else if (args.length === 1) {
        if (typeof args[0] === 'string') {
            name = args[0]
        } else {
            position = args[0]
        }
    } else {
        return null
    }

    if (name !== undefined && depth !== undefined) {
        const stack: NodeInfo[] = [{ node: this, depth: 0 }];
        while (stack.length > 0) {
            const { node, depth: currentDepth } = stack.pop()!;
            if (node.name === name && currentDepth === depth) {
                return node;
            }
            for (const child of node.children) {
                stack.push({ node: child, depth: currentDepth + 1 });
            }
        }
        return null;
    }

    if (name !== undefined) {
        const queue: cc.Node[] = [this];
        while (queue.length > 0) {
            const node = queue.shift()!;
            if (node.name === name) {
                return node;
            }
            queue.push(...node.children);
        }
        return null;
    }

    return this.children[position] || null;
};

